Robotics I

Poznan University of Technology, Institute of Robotics and Machine Intelligence

Laboratory 3: ROS - bags, services, actions and parameters

Goals

• Recap ROS 2 concepts - nodes and topics
• Familiarize with with ROS 2 bags, services, actions and parameters
• Get hands-on experience with the ROS 2 functionalities
• Experiment with TurtleSim simulation

Resources

• ROS 2 Documentation
• Recording and playing back data in ROS 2
• ROS 2 Services
• ROS 2 Actions
• ROS 2 Parameters
• Understanding ROS 2 parameters
• ROS 2 parameters command-line tool
• TurtleSim in ROS 2

TurtleSim

TurtleSim is a lightweight simulator for learning ROS 2. It illustrates what ROS 2 does at the most basic level to give you an idea of what you will do with a real robot or a robot simulation later on.

https://docs.ros.org/en/jazzy/Tutorials/Beginner-CLI-Tools/Introducing-Turtlesim/Introducing-Turtlesim.html

In today’s lab we will be using TurtleSim to practice ROS 2 functionalities in simulated environment. With TurtleSim you can to send velocity commands, subscribe to topics, and handle basic robot control in a fun and engaging way.

To start simulator call:

ros2 run turtlesim turtlesim_node

While to start keyboard control, from the second terminal call the command:

ros2 run turtlesim turtle_teleop_key

Tasks

Note 1: Everything we do today should be done inside the container! To attach another terminal to a running container use the command docker exec -it <CONTAINER NAME> bash.

Note 2: Every time you open a terminal window and want to work with ROS 2 you need to source environmental variables using source /opt/ros/$ROS_DISTRO/setup.bash or source install/setup.bash if you work in a specific ROS 2 workspace (e.g. ~/ros2_ws)!

1. Run docker container based on osrf/ros:jazzy-desktop-full docker image with GUI support. Use docker_run.sh script provided below.

IMAGE_NAME="" # <DOCKER IMAGE REPOSITORY>:<DOCKER IMAGE TAG>
CONTAINER_NAME="" # student ID number

xhost +local:root

XAUTH=/tmp/.docker.xauth
if [ ! -f $XAUTH ]
then
    xauth_list=$(xauth nlist :0 | sed -e 's/^..../ffff/')
    if [ ! -z "$xauth_list" ]
    then
        echo $xauth_list | xauth -f $XAUTH nmerge -
    else
        touch $XAUTH
    fi
    chmod a+r $XAUTH
fi

docker stop $CONTAINER_NAME || true && docker rm $CONTAINER_NAME || true

docker run -it \
    --env="ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST" \
    --env="DISPLAY=$DISPLAY" \
    --env="QT_X11_NO_MITSHM=1" \
    --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" \
    --env="XAUTHORITY=$XAUTH" \
    --volume="$XAUTH:$XAUTH" \
    --privileged \
    --network=host \
    --name="$CONTAINER_NAME" \
    $IMAGE_NAME \
    /bin/bash

2. Install turtlesim package and verify installation following the steps provided in Install TurtleSim.
3. Start TurtleSim with command ros2 run turtlesim turtlesim_node and from another terminal explore available nodes and topics. Then, run ros2 run turtlesim turtle_teleop_key command that allows you to to control the turtle. From the third terminal observe how topic /turtle1/pose changes when you moves the turtle. Take a screenshot of TurtleSim simulator alongside terminal with preview of /turtle1/pose topic and upload it to eKursy.
4. Topic /turtle1/cmd_vel, which is responsible for controlling the turtle’s movement, is of type geometry_msgs/msg/Twist. Use the ros2 topic pub command to publish the turtle control commands.
5. Keep the turtlesim_node running.

ROS 2 Bags

ROS 2 bag is a command line tool for recording and playing back data published to topics and services in your ROS 2 system. It allows users to capture any number of topics and services from sensors, robots, or other devices during experiments or testing and replay it later for debugging, analysis, or simulation purposes. The bag files store the messages in a time-ordered manner in a database, making them useful for offline data analysis and system development. It is intended to be high performance and avoids deserialization and reserialization of the messages. The idea is to:

• have a way of recording the data from multiple components at once
• have a way of replaying the same data in the same way
• have a deterministic and repeatable method for the system’s performance verification

ROS 2 bag has the following subcommands, which can be inspected by calling:

$ ros2 bag -h

Commands:
  burst    Burst data from a bag
  convert  Given an input bag, write out a new bag with different settings
  info     Print information about a bag to the screen
  list     Print information about available plugins to the screen
  play     Play back ROS data from a bag
  record   Record ROS data to a bag
  reindex  Reconstruct metadata file for a bag

ros2 bag record --topics <TOPIC 1 NAME> <TOPIC 2 NAME>

ros2 bag record --all

Once some data has been recorded, you can stop the recording from the terminal with `ros2 bag record’ by pressing CTRL+C. As a result you should see a folder containing a database with ROS 2 bag data corresponding to the time of recording, i.e. rosbag2_2025_03_17-18_26_12/. To inspect the ROS 2 bag, run:

ros2 bag info <PATH TO ROS 2 BAG FILE>

The output should be structured as follows:

Files:             rosbag2_2025_03_18-07_14_08_0.mcap
Bag size:          334.3 KiB
Storage id:        mcap
ROS Distro:        jazzy
Duration:          38.641391213s
Start:             Mar 18 2025 07:14:08.054556029 (1742282048.054556029)
End:               Mar 18 2025 07:14:46.695947242 (1742282086.695947242)
Messages:          4879
Topic information: Topic: /events/write_split | Type: rosbag2_interfaces/msg/WriteSplitEvent | Count: 0 | Serialization Format: cdr
                   Topic: /parameter_events | Type: rcl_interfaces/msg/ParameterEvent | Count: 2 | Serialization Format: cdr
                   Topic: /rosout | Type: rcl_interfaces/msg/Log | Count: 15 | Serialization Format: cdr
                   Topic: /turtle1/cmd_vel | Type: geometry_msgs/msg/Twist | Count: 30 | Serialization Format: cdr
                   Topic: /turtle1/color_sensor | Type: turtlesim/msg/Color | Count: 2416 | Serialization Format: cdr
                   Topic: /turtle1/pose | Type: turtlesim/msg/Pose | Count: 2416 | Serialization Format: cdr
Service:           0
Service information:

To play recorded ROS 2 bag file, simply call:

ros2 bag play <PATH TO ROS 2 BAG FILE>

ROS 2 Services

In ROS 2 services are another method of communication between nodes. While topics are based on publisher-subscriber model, services follow a call-and-response model. Therefore, services only provide data when they are specifically called by a client, unlike topics which allow nodes to subscribe to data streams and get continual updates. To check subcommands of ROS 2 services simply call:

$ ros2 service -h

Commands:
  call  Call a service
  echo  Echo a service
  find  Output a list of available services of a given type
  info  Print information about a service
  list  Output a list of available services
  type  Output a service's type

https://docs.ros.org/en/jazzy/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Services/Understanding-ROS2-Services.html

To check available services call:

ros2 service list

In our case, when turtlesim_node is running, the list of services should be as follows:

/clear
/kill
/reset
/spawn
/turtle1/set_pen
/turtle1/teleport_absolute
/turtle1/teleport_relative
/turtlesim/describe_parameters
/turtlesim/get_parameter_types
/turtlesim/get_parameters
/turtlesim/get_type_description
/turtlesim/list_parameters
/turtlesim/set_parameters
/turtlesim/set_parameters_atomically

Let’s look more closely at the /clear service using:

$ ros2 service info /clear

Type: std_srvs/srv/Empty
Clients count: 0
Services count: 1

This service is empty, which means that it takes no arguments when the service is called (i.e., it sends no data when making a request and receives no data when receiving a response).

Let’s call this service. To do this, use command ros2 service call with the following parameters:

ros2 service call <SERVICE NAME> <SERVICE TYPE>

In our case it will be:

ros2 service call /clear std_srvs/srv/Empty

Now, let’s look at the case where the service has arguments, i.e., /spawn, which allow us to spawn a new turtle at a given location and orientation. To inspect service content, firstly check service type:

$ ros2 service type /spawn

turtlesim/srv/Spawn

Then, using ros2 interface show command, inspect content of the service:

$ ros2 interface show turtlesim/srv/Spawn

float32 x
float32 y
float32 theta
string name # Optional.  A unique name will be created and returned if this is empty
---
string name

Let’s create a new turtle using /spawn service:

ros2 service call /spawn turtlesim/srv/Spawn '{x: 2, y: 2, theta: 0.2}'

After calling this command, a new turtle named turtle2 appeared in the place we specified in a service parameters

To remove additional turtles and clear simulation, simply call:

ros2 service call /reset std_srvs/srv/Empty

ROS 2 Actions

In ROS 2, actions are a type of communication intended for long-running tasks, consisting of three parts: a goal, feedback, and a result. Actions are based on topics and services. Their functionality is similar to services, except actions can be canceled. They also provide steady feedback, as opposed to services which return a single response. An action client node sends a goal to an action server node, which acknowledges the goal and returns a stream of feedback and a result. To inspect subcommands related to ROS 2 actions call:

$ ros2 action -h

Commands:
  info       Print information about an action
  list       Output a list of action names
  send_goal  Send an action goal
  type       Print a action's type

Source: https://docs.ros.org/en/jazzy/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Actions/Understanding-ROS2-Actions.html

To check available actions call:

ros2 action list

In our case, each turtle has only one action - /turtle1/rotate_absolute. To inspect this action firstly check its type calling:

$ ros2 action type /turtle1/rotate_absolute 

turtlesim/action/RotateAbsolute

Then, using ros2 interface show command, inspect content of the action:

$ ros2 interface show turtlesim/action/RotateAbsolute

# The desired heading in radians
float32 theta
---
# The angular displacement in radians to the starting position
float32 delta
---
# The remaining rotation in radians
float32 remaining

Let’s perform an action by calling the command:

ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute '{theta: 1.2}'

ROS 2 Parameters

A parameter is a configuration value of a node, allowing storing and manipulating node settings. They can be stored as integers, floats, booleans, strings, or lists. In ROS 2, each node maintains its own parameters, which can be set from the command line or using YAML file. In simple cases, YAML looks very natural: 1 is an integer, 1.0 is a float, one is a string, true is a boolean, [1, 2, 3] is a list of integers. ROS 2 has many commands that can be used on parameters. You can find them by calling:

$ ros2 param -h

Commands:
  delete    Delete parameter
  describe  Show descriptive information about declared parameters
  dump      Show all of the parameters of a node in a YAML file format
  get       Get parameter
  list      Output a list of available parameters
  load      Load parameter file for a node
  set       Set parameter

To list available parameters call:

ros2 param list

For TurtleSim node, the list of parameters looks like this:

/turtlesim:
  background_b
  background_g
  background_r
  holonomic
  qos_overrides./parameter_events.publisher.depth
  qos_overrides./parameter_events.publisher.durability
  qos_overrides./parameter_events.publisher.history
  qos_overrides./parameter_events.publisher.reliability
  start_type_description_service
  use_sim_time

To show descriptive information about declared parameter(s) use describe subcommand:

ros2 param describe <NODE NAME> <PARAMETER NAME> [<PARAMETER NAME>]

To get parameter simply call:

ros2 param get <NODE NAME> <PARAMETER NAME>

While to show all of the parameters of a node in a YAML file format use the command:

ros2 param dump <NODE NAME>

To set parameter use the command:

ros2 param set <NODE NAME> <PARAMETER NAME> <VALUE>

While when you plan to set more than one parameter it may be convenient to use the load subcommand. It loads a YAML file.

ros2 param load <NODE NAME> <PARAMETER FILE>

Parameters background_b, background_g, and background_r refer to background window color, so let’s change it! For example call:

ros2 param set /turtlesim background_r 255

The result is as follows:

Tasks

Note 1: Everything we do today should be done inside the container! To attach another terminal to a running container use the command docker exec -it <CONTAINER NAME> bash.

Note 2: Every time you open a terminal window and want to work with ROS 2 you need to source environmental variables using source /opt/ros/$ROS_DISTRO/setup.bash or source install/setup.bash if you work in a specific ROS 2 workspace (e.g. ~/ros2_ws)!

6. Use ros2 param dump to save the current node parameters to the YAML file. Using the VS COde IDE, attach a docker container and open the previously saved YAML file. Change the values of the parameters background_b, background_g and background_r to whatever you want and save the file. Then load it and check how the background color was changed. Upload the eKursy YAML file and a screenshot of the TurtleSim window.
7. Use ROS 2 bag commands to record turtle control commands (~60 seconds) and then play them back to reproduce the object’s movements. Run the TurtleSim simulator and from the second terminal run the keyboard control node (ros2 run turtlesim turtle_teleop_key). In another terminal, start recording all topics while manipulating the turtle from the terminal running the turtle control node. After a while stop recording and reset the simulator window by calling the ROS 2 /reset service. Finally, play the ROS 2 bag file and watch the turtle reproduce the movements. Upload the recorded ROS 2 bag file to eKursy.